#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <libelf.h>
#include <elf.h>
#include <gelf.h>
#include <err.h>
#include <unistd.h>
#include <sysexits.h>
#include <fcntl.h>
#include <math.h>
//#include <vis.h>
struct prefijo
{
	char *insPre;
	char *addSizPre;
	char *opeSizPre;
	char *segOve;

};
struct codigoOperacion
{
	char *byte1;
	char *byte2;
};

#define PRINT_FMT 	"%-20s 0x%jx\n"
# define NL() do { ( void ) printf( "\n" ); } while (0)

void menu();
void VerificaOpcion(char *opcion, char *FileName,int i);
void LeerBinario(char *FileName);
void ReadFile(char *FileName, char *OutputFileName);
void DissasembleHeaderELF(char *Fichero, char *OutputFileName);
void ReadingELFExecutableHeader(char *Fichero, int fd);
void print_ptype(size_t pt);
void ReadingProgramHeaderTable(char *Fichero, int fd);
void ListingSectionNames(char *Fichero, int fd);
void ValidateFileSize(FILE *Fichero);
void DissasembleGeneralPropuseInstructions(FILE *Fichero);
void Dissasemblex87FPUInstructions(FILE *Fichero);
void DissasembleSIMDStageManagmentInstruccions(FILE *Fichero);
char* substr(char* cadena, int comienzo, int longitud);
void ReadSection(Elf64_Off sectionoffset,size_t sectionSize,char *Filename);
int validateFileSize(char *FileName);
void validatePrefix(char *prefixbyte);
int DectoBin (int x, char arrbin[]);
char* StringtoHex(char *prefixbyte);
char* StringtoBin(char *string);
void operationCode(char *op);
int validateFileSize(char *FileName)
{
	FILE *archivo;

	// longitud del archivo de lectura;
	unsigned long fileLen;
	long tamanomaximo=104857600;
	long tamanominimo=10;
	archivo = fopen(FileName,"rb");
	//Verifica si el archivo se puede abrir
	if (archivo == NULL){
		printf("\nError de apertura del archivo %s. \n\n",FileName);
	}else{
		fseek(archivo,0,SEEK_END);
		fileLen=ftell(archivo);
		//verifica si la longitud es correcta de acuerdo requerimientos
		if (fileLen>=tamanominimo && fileLen<=tamanomaximo)
			return 1;
		else
		{
			 printf("Archivo fuera del rango permitido: 1KB - 100MB\n");
			return 0;
			exit (1);
		}

	}
	return 0;
}


int printELFHeaders=0;
int main(int argc,char *argv[])
{
	//char entrada[100]="";
	char NombreArchivo[50]="";
	int i=0;
	char opcion[20]="";
	char opt[1]="";

    if (argc==1)
    {
    	menu();
    	do
    	{
			printf("Ingrese la opción elegida....\n");
			gets(opt);
			strcat(opcion,opt);
			i=i+1;
    	} while(*opt!='0');
    	printf("Ingrese ubicación del archivo a analizar \n");
        gets(NombreArchivo);
    	//sscanf(entrada,"%s",NombreArchivoSalida);
       	printf("Analizando %s",NombreArchivo);
    	VerificaOpcion(opcion,NombreArchivo,i);
    	return 0;

    }
    if (argc>3)
    {
    	printf("Demasiados Argumentos\n");
     return 1;
    }
    if (argc==2)
        {
    	VerificaOpcion("1",argv[1],1);
         return 0;
        }
    if (argc==3)
        {

    	i=strlen(argv[1]);
    	//printf("%s-%s-%d",argv[1],argv[2],i);
    	VerificaOpcion(argv[1],argv[2],i);
    	return 0;
        }
    return 0;
}

void VerificaOpcion(char *opcion, char *FileName, int i)
{
	int opt,j;
	char *NombreArchivo=FileName;
	char NombreArchivoSalida[50]="Archivo.txt";
	char *copt;
	char *opt4;
	opt4=strstr(opcion,"4");
	int val;
	//printf("%s",NombreArchivo);
	if (opt4)
	{
		printf("\n Ingrese ubicación del archivo de salida\n");
		gets(NombreArchivoSalida);
	}
	val=validateFileSize(NombreArchivo);
	if (val==1)
	{
	for (j=0;j<=i;j++)
	{
		//printf("%d",j);
		copt=substr(opcion,j,1);
		opt= atoi(copt);
		//printf("%s",copt);
		switch (opt)
		{

		case 0:
			break;
		case 1:
		{

//			ReadFile(NombreArchivo,NombreArchivoSalida);
			printELFHeaders=1;
			DissasembleHeaderELF(NombreArchivo,NombreArchivoSalida);
			break;
		}
		case 2:
		{
			ReadFile(NombreArchivo,NombreArchivoSalida);
			//LeerBinario(NombreArchivo);
			break;
		}
		case 3:
		{
			printELFHeaders=1;
			DissasembleHeaderELF(NombreArchivo,NombreArchivoSalida);
			break;
		}
		case 4:
		{
			break;
		}
		case 5:
		{
			DissasembleHeaderELF(NombreArchivo,NombreArchivoSalida);
			break;
		}

		}
	}
	}
	/*if (*opcion=='2')
	{
		ReadFile(NombreArchivo);

	}
	if (*opcion=='3')
	{
		printELFHeaders=1;
		DissasembleHeaderELF(NombreArchivo);
	}
	if (*opcion=='5')
	{
			DissasembleHeaderELF(NombreArchivo);
	}*/


}
void menu()
{
    printf("\n Opciones:");
    printf("\n 1 Mostrar Todas");
    printf("\n 2 Mostrar contenido binario");
    printf("\n 3 Mostrar Cabeceras ELF");
    printf("\n 4 Archivo de salida");
    printf("\n 5 Desensamblar instrucciones de proposito general");
    printf("\n 6 Desensamblar instrucciones x87");
    printf("\n 7 Desensamblar instrucciones Intel MMX");
    printf("\n 8 Desensamblar extenciones SSE");
    printf("\n 9 Desensamblar extenciones SSE2");
    printf("\n 10 Desensamblar extenciones SSE3");
    printf("\n 11 Desensamblar extenciones SSE4");
    printf("\n 12 Desensamblar extenciones SSSE3");
    printf("\n 13 Desensamblar instrucciones AESNI and PCLMULQDQ");
    printf("\n 0 Salir \n");
}


void ReadFile(char *Filename, char *OutputFileName)
{
	//archivo de lectura
	FILE *archivo;
	// archivo de escritura
	FILE *archivoBinario;
	// longitud del archivo de lectura;
	unsigned long fileLen;
	// caracter para validar nueva linea
	char nuevalinea=10;
	// tamano maximo y minimo de archivo
	long tamanomaximo=104857600;
	long tamanominimo=10;
	// buffer para almacenar los caracteres leidos
	char buffer;
	int caracter;
	// cadena que contiene el caracter en hexadecimal
	char Hexcaracter[8];
	//Abre los archivos para su uso correspondiente
	archivo = fopen(Filename,"rb");
	archivoBinario= fopen("Binario.dat","wb");
	//Verifica si el archivo se puede abrir
	        if (archivo == NULL){

	                printf("\nError de apertura del archivo %s. \n\n",Filename);
	        }else{


	            printf("\nEl contenido del archivo de %s \n\n",Filename);
	            // obtiene la longitud del archivo en bits
	            fseek(archivo,0,SEEK_END);
	            fileLen=ftell(archivo);
	            //printf("Tamano %lu \n",fileLen);
	           int i=0,j=0;
	           //verifica si la longitud es correcta de acuerdo requerimientos
	            if (fileLen>=tamanominimo && fileLen<=tamanomaximo)
	           {
	            fseek(archivo,0,SEEK_SET);
	            //extrae caracter por caracter hasta final de archivo
	           while(!feof(archivo))
	            {
	            	//fread(buffer,i,8,archivo);
	        	   //obtiene cada caracter
	        	   buffer=fgetc(archivo);
	        	   caracter= (int)buffer;
	        	   //transforma caracter en su correspondiente hexadecimal
	        	   sprintf(Hexcaracter,"%x",caracter);
	        	   printf("%x",buffer);
	        	   fputs(Hexcaracter,archivoBinario);
	        	   //printf("%s",Hexcaracter);
	            	//fwrite(buffer,i,8,archivoBinario);
	            	i=i+1;
	            	// le da formato de salida en pantalla
	            	if (i==4)
	            	{
	            		printf(" ");
	            		fputs(" ",archivoBinario);
	            		i=0;
	            		j=j+1;
	            	}
	            	if (j==7)
	            	{	j=0;
	            		fputs("\n",archivoBinario);
	            		printf("\n");
	            	}
	            	if (buffer==nuevalinea)
	            	{
	            		fputs("\n",archivoBinario);
	            		printf("\n");
	            	}
	           }
	           printf("\n");
	           }
	           else
	        	   printf("Archivo fuera del rango permitido: 1KB - 100MB\n");



	        }
	        //cierra archivos
	        fclose(archivo);
	        fclose(archivoBinario);

}
void ReadingELFExecutableHeader(char *Fichero, int fd)
{
	GElf_Ehdr ehdr;
	int i;
	char *id;
	char bytes[8];
	Elf *e;
	size_t n;
//elf_begin()takes an open file descriptor and converts it an Elf handle according to the command specified (ELF_C_READ).
	if (( e = elf_begin ( fd , ELF_C_READ , NULL )) == NULL )
		errx ( EX_SOFTWARE , " elf_begin () failed : %s. " ,elf_errmsg ( -1));
//elf_kind() returns the kind of object associated with an Elf han-dle.
	if ( elf_kind (e) != ELF_K_ELF )
		errx ( EX_DATAERR , "%s is not an ELF object. " ,Fichero);
//gelf_getehdr() will translate the ELF executable header in the ELF GElf Ehdr.
	if ( gelf_getehdr (e, &ehdr ) == NULL )
		errx ( EX_SOFTWARE , " getehdr() failed : %s. " ,elf_errmsg ( -1));
//gelf_getclass retrieves the ELF class of the object being examined. 32bits o 64bits
	if (( i = gelf_getclass (e)) == ELFCLASSNONE )
		errx ( EX_SOFTWARE , " getclass() failed : %s. " ,	elf_errmsg ( -1));
	( void ) printf ( " %s : %d - bit ELF object \n " , Fichero,i == ELFCLASS32 ? 32 : 64);
//elf getident function to retrieve the contents of the e_ident[] array from the underlying file.
	if (( id = elf_getident (e, NULL )) == NULL )
		errx ( EX_SOFTWARE , " getident() failed : %s." ,elf_errmsg ( -1));
	( void ) printf ( " %3s e_ident [0..%1d ] %7s " , " " ,EI_ABIVERSION , " " );

	for ( i = 0; i <= EI_ABIVERSION ; i ++)
	{
		//(void) vis( bytes,i[i],VIS_WHITE, 0);
		bytes[i]=(char)id[i];

		//if (bin==1)
		(void) printf ( " [ ’%s’ %x ] ",bytes , id[i]);
	}
	(void) printf ( " \n " );
	printf(PRINT_FMT,"e_type",(uintmax_t)ehdr.e_type);
	printf(PRINT_FMT,"e_machine",(uintmax_t)ehdr.e_machine);
	printf(PRINT_FMT,"e_version",(uintmax_t)ehdr.e_version);
	printf(PRINT_FMT,"e_entry",(uintmax_t)ehdr.e_entry);
	printf(PRINT_FMT,"e_phoff",(uintmax_t)ehdr.e_phoff);
	printf(PRINT_FMT,"e_shoff",(uintmax_t)ehdr.e_shoff);
	printf(PRINT_FMT,"e_flags",(uintmax_t)ehdr.e_flags);
	printf(PRINT_FMT,"e_ehsize",(uintmax_t)ehdr.e_ehsize);
	printf(PRINT_FMT,"e_phentsize",(uintmax_t)ehdr.e_phentsize);
	printf(PRINT_FMT,"e_shentsize",(uintmax_t)ehdr.e_shentsize);
	if ( elf_getshdrnum(e,&n )!= 0)
		errx( EX_SOFTWARE , " getshdrnum() failed : %s." ,elf_errmsg ( -1));
	( void ) printf ( PRINT_FMT , "(shnum)" , (uintmax_t) n );
	if ( elf_getshdrstrndx(e,&n)!= 0)
		errx ( EX_SOFTWARE , " getshdrstrndx () failed : %s." ,elf_errmsg ( -1));
	( void ) printf( PRINT_FMT , "(shstrndx)" , (uintmax_t)n );
	if ( elf_getphdrnum(e,&n)!= 0)
		errx ( EX_SOFTWARE , " getphdrnum() failed : %s." ,elf_errmsg ( -1));
	( void ) printf ( PRINT_FMT ,"(phnum)",(uintmax_t)n );
	( void ) elf_end(e);

	//exit ( EX_OK );

}
void print_ptype( size_t pt )
{
	char * s ;

	# define C(V) case PT_ ## V:s=#V ; break
	switch (pt) {
		C(NULL);
		C(LOAD);
		C(INTERP);
		C(NOTE);
		C(PHDR);
		C(TLS);
		C(SUNWBSS);
		C(SUNWSTACK);
		//C(SUNWCAP);
		C(DYNAMIC);
		C(SHLIB);
		//C(SUNW_UNWIND);
		//C(SUNWDTRACE);
		default :
			s = "Unknown" ;
			break ;
	}
	(void) printf( " \"%s\" ",s );
	# undef C
}

void ReadingProgramHeaderTable(char *Fichero, int fd)
{
	int i;
	Elf * e ;
	//char *byte[5];
	size_t n ;
	GElf_Phdr phdr ;
	printf("\nReading Program %s Header Table\n",Fichero);

	if (( e = elf_begin ( fd , ELF_C_READ , NULL )) == NULL )
		errx ( EX_SOFTWARE , " elf_begin () failed : %s. " ,elf_errmsg ( -1));
	if ( elf_kind ( e ) != ELF_K_ELF )
		errx ( EX_DATAERR , " \"%s \" is not an ELF object.",Fichero);
	if ( elf_getphdrnum (e , & n ) != 0)
		errx ( EX_DATAERR , " elf_getphdrnum () failed : %s. " ,	elf_errmsg ( -1));
	for ( i = 0; i < n ; i ++)
	{
		if (gelf_getphdr(e,i,&phdr)!= & phdr )
		errx (EX_SOFTWARE, " getphdr () failed : %s." ,elf_errmsg ( -1));
		( void ) printf ( "PHDR %d :\n",i );

		#define	PRINT_FIELD(N) do { \
		( void ) printf (PRINT_FMT,#N,(uintmax_t)phdr.N ); \
		} while (0)

		PRINT_FIELD(p_type);
		print_ptype(phdr.p_type);
		NL();
		PRINT_FIELD(p_offset);
		PRINT_FIELD(p_vaddr);
		PRINT_FIELD(p_paddr);
		PRINT_FIELD(p_filesz);
		PRINT_FIELD(p_memsz);
		PRINT_FIELD(p_flags);
		(void) printf (" [");
		if (phdr.p_flags &PF_X)
		(void) printf (" execute");
		if (phdr.p_flags &PF_R )
		(void) printf (" read");
		if (phdr.p_flags &PF_W)
		(void) printf (" write");
		printf(" ] ");
		NL ();
		PRINT_FIELD( p_align );
		NL ();
		}
		(void) elf_end(e);
		//(void) close(fd);
		//exit ( EX_OK );

}
void ListingSectionNames(char *Fichero, int fd)
{
	Elf * e;
	char *name;
	//char *p;
	//char pc[4*sizeof(char)];
	Elf_Scn *scn;
	//Elf_Data *data;
	GElf_Shdr shdr;
	//size_t n;
	size_t shstrndx;
	Elf64_Off sectionOffset;
	size_t sectionSize;
	if ((e=elf_begin(fd,ELF_C_READ,NULL))==NULL)
		errx( EX_SOFTWARE,"elf_begin() failed: %s.",elf_errmsg ( -1));
	if (elf_kind(e)!=ELF_K_ELF)
		errx(EX_DATAERR,"%s is not an ELF object.",Fichero);
	if (elf_getshdrstrndx(e,&shstrndx)!= 0)
		errx(EX_SOFTWARE,"elf_getshdrstrndx() failed : %s.",	elf_errmsg ( -1));
	scn = NULL ;
	while ((scn=elf_nextscn(e,scn))!=NULL)
	{
		if (gelf_getshdr(scn,&shdr)!=&shdr)
			errx ( EX_SOFTWARE , "getshdr() failed: %s." ,elf_errmsg ( -1));
		if (( name=elf_strptr(e,shstrndx,shdr.sh_name))== NULL )
			errx ( EX_SOFTWARE , " elf_strptr() failed : %s." ,elf_errmsg ( -1));
		(void) printf ( "Section %-4.4jd %s\n",(uintmax_t) elf_ndxscn(scn),name);
		sectionOffset=shdr.sh_offset;
		sectionSize=shdr.sh_size;
		//if (*name=='.text')
		ReadSection(sectionOffset,sectionSize,Fichero);
	}
	if ((scn=elf_getscn(e,shstrndx))==NULL)
		errx(EX_SOFTWARE,"getscn() failed : %s.",elf_errmsg ( -1));
	if (gelf_getshdr(scn,&shdr)!=&shdr)
		errx(EX_SOFTWARE,"getshdr(shstrndx)failed: %s.",elf_errmsg ( -1));
	(void) printf(".shstrab:size =%jd \n",(uintmax_t) shdr.sh_size);
	//data=NULL;
	//n=0;
	/*while (n<shdr.sh_size && (data=elf_getdata(scn,data))!=NULL)
	{
		p=(char*)data->d_buf;
		while (p<(char*) data->d_buf + data->d_size )
		{
			//if(vis(pc,*p,VIS_WHITE,0))
				printf("%s",pc);
			n ++; p ++;
			(void)putchar((n%16)?' ':'\n');
		}
	}*/
	(void)putchar('\n');
	(void)elf_end(e);


}
void DissasembleHeaderELF(char *Fichero, char *OutputFileName)
{
	FILE *archivo;
	archivo = fopen(Fichero,"rb");
	 if (archivo == NULL)
	 {
		 printf("\nError de apertura del archivo %s. \n\n",Fichero);
	 }
	 else
	 {

		printf("\nEl contenido del archivo de %s \n\n",Fichero);
		int fd;

//A call to elf version is mandatory before other functions in the ELF library can be invoked

		if ( elf_version ( EV_CURRENT ) == EV_NONE )
			errx ( EX_SOFTWARE , " ELF library initialization failed : %s " , elf_errmsg ( -1));
//
		if (( fd = open ( Fichero , O_RDONLY , 0)) < 0)
			err ( EX_NOINPUT , " open \"%s \" failed ", Fichero);
		if (printELFHeaders==1)
		{
			ReadingELFExecutableHeader(Fichero,fd);
			ReadingProgramHeaderTable(Fichero,fd);
		}
		ListingSectionNames(Fichero,fd);
		( void ) close(fd);
	 }
	 fclose(archivo);
}
void ValidateFileSize(FILE *Fichero)
{}
void DissasembleGeneralPropuseInstructions(FILE *Fichero)
{}
void Dissasemblex87FPUInstructions(FILE *Fichero)
{}
void DissasembleSIMDStageManagmentInstruccions(FILE *Fichero)
{}
char* substr(char* cadena, int comienzo, int longitud)
{
	if (longitud == 0) longitud = strlen(cadena)-comienzo-1;

	char *nuevo = (char*)malloc(sizeof(char) * longitud);

	strncpy(nuevo, cadena + comienzo, longitud);
	//printf("%s",nuevo);
	return nuevo;
}
void LeerBinario(char *FileName)
{
	FILE * pFile;
	  long lSize;
	  char * buffer;
	  size_t result;

	  pFile = fopen ( FileName , "rb" );
	  if (pFile==NULL)
	  {fputs ("File error",stderr); exit (1);}

	  // obtain file size:
	  fseek (pFile , 0 , SEEK_END);
	  lSize = 4;
	  rewind (pFile);

	  // allocate memory to contain the whole file:
	  buffer = (char*) malloc (sizeof(char)*lSize);
	  if (buffer == NULL) {fputs ("Memory error",stderr); exit (2);}

	  // copy the file into the buffer:
	  while (!feof(pFile))
	  {
	  result = fread (buffer,1,lSize,pFile);
	  printf("%s ",buffer);
	  }
	  if (result != lSize) {fputs ("Reading error",stderr); exit (3);}

	  /* the whole file is now loaded in the memory buffer. */

	  // terminate
	  fclose (pFile);
	  free (buffer);
}
void ReadSection(Elf64_Off sectionoffset,size_t sectionSize,char *Filename)
{
	FILE * pFile;
	long lSize;
	char * buffer;
	size_t result;
	int caracter;
	pFile = fopen (Filename , "rb" );
	if (pFile==NULL)
	{
		fputs ("File error",stderr); exit (1);
	}
	// obtain file size:
	fseek (pFile, sectionoffset,SEEK_SET );
	lSize = 16;
	//rewind (pFile);
	char Hexcaracter[8];
	int i=0;
	int finSeccion= (int)sectionSize;
	char *prefixSection;//4
	char *opcode;//2
	char *modreg;//1
	char *osib;//1
	char *displacement;//4
	char *immediateData;//4

	printf("%d-%d\n",(int)sectionoffset,finSeccion);

	// allocate memory to contain the whole file:
	 buffer = (char*) malloc (sizeof(char)*lSize);
	if (buffer == NULL)
	{
		fputs ("Memory error",stderr); exit (2);
	}
	 // copy the file into the buffer:
	for (i=0;i<=finSeccion;i=i+16 )
	{
	  result = fread (buffer,1,lSize,pFile);
	  caracter= (int)buffer;
	   //transforma caracter en su correspondiente hexadecimal
	  sprintf(Hexcaracter,"%x",caracter);
	   //printf("%d",caracter);
	 // printf("%s ",buffer);
	  prefixSection=substr(buffer,0,4);
	  opcode=substr(buffer,4,2);
	  modreg=substr(buffer,6,1);
	  osib=substr(buffer,7,1);
	  displacement=substr(buffer,8,4);
	  immediateData=substr(buffer,12,4);
	  printf("\n%s%s%s%s%s%s     ",prefixSection,opcode,modreg,osib,displacement,immediateData);
	 //validatePrefix(prefixSection);
	 //operationCode(opcode);
	  printf("%s",StringtoHex(prefixSection));
	 printf("%s ",StringtoHex(opcode));
	 printf("%s ",StringtoHex(modreg));
	 printf("%s ",StringtoHex(osib));
	 printf("%s ",StringtoHex(displacement));
	 printf("%s ",StringtoHex(immediateData));
	}
	printf("%s","\n");
	if (result > lSize) {
		fputs ("Reading error",stderr); exit (3);
	}
	  // terminate
	  fclose (pFile);
	  free (buffer);

}
char* StringtoBin(char *string)
{
	int longitud=strlen(string);
		int tamano=8*longitud;
		char *caracter;
		int intCaracter,i;
		char cadena[tamano];
		char binario[8];
		char *bin;
		strcpy(cadena,"");
		for(i=0;i<longitud;i++)
			{
				caracter=substr(string,i,1);
				intCaracter= (int)*caracter;
				DectoBin (intCaracter, binario);

				strcat(cadena,binario);
			}
		return bin=cadena;
}

void validatePrefix(char *prefixbyte)
{

	struct prefijo prefix;
	char *cadena;
	cadena=StringtoBin(prefixbyte);
		//printf("\n%s\n",cadena);
		prefix.insPre=substr(cadena,0,8);
		prefix.addSizPre=substr(cadena,8,8);
		prefix.opeSizPre=substr(cadena,16,8);
		prefix.segOve=substr(cadena,24,31);
	printf("Prefijo %s/%s/%s/%s	",prefix.insPre,prefix.addSizPre,prefix.opeSizPre,prefix.segOve);
}

char* StringtoHex(char *prefixbyte)
{
	char *caracter;
	int intCaracter,i;
	char Hexcaracter[2];
	int longitud=strlen(prefixbyte);
	int tamano=longitud*2;
	//int binario;
	char cadena[tamano];
	char *hex;
	//char bin[8];
	//char *binario;
	strcpy(cadena,"");
	for(i=0;i<longitud;i++)
	{
		//printf("\n%s\n",cadena);
		caracter=substr(prefixbyte,i,1);
		intCaracter= (int)*caracter;
		if (intCaracter<16)
		sprintf(Hexcaracter,"0%x",intCaracter);
		else
		sprintf(Hexcaracter,"%x",intCaracter);
		strcat(cadena,Hexcaracter);

	}
	return hex=cadena;
}

int DectoBin (int x, char arrbin[])
{
int i=0,j;
char zero='0';
char uno='1' ;
char arreglo[8];
//x=101;
while(x>=2)
 {
	if(fmod(x,2)==0)
		arreglo[i] = zero;
	if(fmod(x,2)==1)
		arreglo[i] = uno;
  x = x/2;
i=i+1;
 }
if(x==0)
	arreglo[i]=zero;
else
	arreglo[i]=uno;

for(j=i+1;j<8;j++){
	arreglo[j]=zero;
}

arrbin[0]=arreglo[7];
arrbin[1]=arreglo[6];
arrbin[2]=arreglo[5];
arrbin[3]=arreglo[4];
arrbin[4]=arreglo[3];
arrbin[5]=arreglo[2];
arrbin[6]=arreglo[1];
arrbin[7]=arreglo[0];
//printf("*%s;",arrbin);
return i;
}
void operationCode(char *op)
{
	struct codigoOperacion opCode;
	char *cadena;
	cadena=StringtoBin(op);
	opCode.byte1=substr(cadena,0,8);
	opCode.byte2=substr(cadena,8,8);
		printf("OP; %s/%s	",opCode.byte1,opCode.byte2);
}
